package com.yidu.hbatsft.action;

import com.yidu.hbatsft.domain.AtsEmpExpert;
import com.yidu.hbatsft.domain.AtsSchemeAudit;
import com.yidu.hbatsft.domain.AtsSchemeExpert;
import com.yidu.hbatsft.service.AtsEmpExpertService;
import com.yidu.hbatsft.service.AtsSchemeAuditService;
import com.yidu.hbatsft.service.MentalityAtsSchemeAuditService;
import com.yidu.hbatsft.service.MentalityAtsSchemeExpertService;
import com.yidu.privilege.vo.UserVo;
import com.yidu.utils.FileTools;
import com.yidu.utils.Message;
import com.yidu.utils.Tools;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.*;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
  *@ClassName MentalityAtsSchemeExpertController
  *@Description 专家咨询控制类
  *@Author 肖瑜
  *@Date 2020/1/9 9:15
  *@Version 1.0
**/
@Controller
@RequestMapping("/mase")
public class MentalityAtsSchemeExpertController {

    //文件上传管理工具
    @Resource
    FileTools fileTools;

    //专家咨询service
    @Resource
    MentalityAtsSchemeExpertService atsSchemeExpertService;

    //专家service
    @Resource
    AtsEmpExpertService atsEmpExpertService;

    //方案审核service
    @Resource
    MentalityAtsSchemeAuditService atsSchemeAuditService;

    /**
     * 查询所有方案
     * @param pageNum 页数
     * @param pageSize 条数
     * @param expert 专家咨询对象
     * @return map 集合
     */
    @ResponseBody
    @RequestMapping("MentalityExpertFindAll")
    public Map<String, Object> findAll(@RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize,AtsSchemeExpert expert) {
        //创建map集合
        Map<String, Object> map = new HashMap<String, Object>();
        //调用查询所有专家咨询方法
        List<AtsSchemeExpert> list = atsSchemeExpertService.findAll(pageNum, pageSize,expert);
        //将code设置为0
        map.put("code", 0);
        //将msg设置为空
        map.put("msg", "");
        //统计所有条数
        map.put("count", atsSchemeExpertService.count(expert));
        //集合放入map
        map.put("data", list);
        //返回集合
        return map;
    }

    /**
     * 专家回复
     * @param file 文件
     * @param schemeId 方案ID
     * @return message 消息对象
     */
    @ResponseBody
    @RequestMapping("reply")
    public Message reply(MultipartFile file,Integer schemeId){
        //创建消息对象
        Message msg = new Message();
        try {
            //调用上传文件方法
            String filePath = fileTools.saveFile("reply",file);
            //创建专家咨询对象
            AtsSchemeExpert ase = new AtsSchemeExpert();
            //设置审核状态为专家已回复
            ase.setAuditState("40");
            //设置返回结果
            ase.setResults(filePath);
            //设置方案ID
            ase.setSchemeId(schemeId);
            //调用根据方案ID修改专家咨询
            int rows = atsSchemeExpertService.updateByschemeId(ase);
            //如果成功
            if(rows>0){
                msg.setNum(1);
                msg.setMsg("回复成功");
            //失败
            }else{
                msg.setNum(0);
                msg.setMsg("回复失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //返回消息
        return msg;
    }

    /**
     * 查询所有
     * @param pageNum 页数
     * @param pageSize 条数
     * @param expert 专家咨询对象
     * @return map 集合
     */
    @ResponseBody
    @RequestMapping("selectByReply")
    public Map<String, Object> selectByReply(@RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize,AtsSchemeExpert expert) {
        //创建map集合
        Map<String, Object> map = new HashMap<String, Object>();
        //调用查询所有专家咨询
        List<AtsSchemeExpert> list = atsSchemeExpertService.selectByReply(pageNum, pageSize);
        //将code设置为0
        map.put("code", 0);
        //将msg设置为空
        map.put("msg", "");
        //统计所有条数
        map.put("count", atsSchemeExpertService.count(expert));
        //集合放入map
        map.put("data", list);
        //返回集合
        return map;
    }

    /**
     * 领导审核
     * @param asa 审核对象
     * @param ase 专家咨询对象
     * @param request 请求对象
     * @return message 消息对象
     */
    @ResponseBody
    @RequestMapping("add")
    public Message add(AtsSchemeAudit asa, AtsSchemeExpert ase, HttpServletRequest request){
        //获取session对象
        HttpSession session = request.getSession();
        //从session获取manager
        UserVo user = (UserVo)session.getAttribute("manager");
        //设置审核时间为当前时间
        asa.setAuTime(Tools.getCurDateTime());
        //判断审核状态是否为On
        if("on".equals(asa.getAuditState())){
            //设置审核状态为同意
            asa.setAuditState("20");
            ase.setAuditState("20");
        }else{
            //设置审核状态为不同意
            asa.setAuditState("21");
            ase.setAuditState("21");
        }
        //设置审核排序为1
        asa.setSort(1);
        //设置审核创建人为当前登录人
        asa.setCreater(user.getUsName());
        //设置审核时间为当前时间
        asa.setCreatTime(new Date());
        //设置审核是否有效为有效
        asa.setIsva(1);
        //设置审核的外键为专家咨询的方案ID
        asa.setSaId(String.valueOf(ase.getSchemeId()));
        //调用根据外键修改审核方法
        int i = atsSchemeAuditService.updateAuditBySaId(asa);
        //调用修改审核方法
        atsSchemeExpertService.updateByschemeKey(ase);
        //创建消息对象
        Message m = new Message();
        //如果成功
        if(i>0){
            m.setMsg("成功");
            m.setNum(1);
        //失败
        }else{
            m.setMsg("失败");
            m.setNum(0);
        }
        //返回消息
        return m;
    }

    /**
     * 查询所有专家
     * @return list 集合
     */
    @ResponseBody
    @RequestMapping("findAllExpert")
    public List<AtsEmpExpert> findAllExpert(){
        //调用查询所有专家方法
        List<AtsEmpExpert> alls = atsEmpExpertService.findAlls();
        //返回集合
        return alls;
    }

    /**
     * 根据方案外键查询专家咨询
     * @param id 方案ID
     * @return AtsSchemeExpert 专家咨询对象
     */
    @ResponseBody
    @RequestMapping("findBySaId")
    public AtsSchemeExpert findBySaId(Integer id){
        System.out.println("idiidid:"+id);
        //创建专家咨询对象
        AtsSchemeExpert ats =null;
        //判断id不为空
        if(id!=null){
            //调用根据方案外键查询专家咨询
            ats  = atsSchemeExpertService.selectByPrimaryKey(id);
        }
        //判断方案对象为空
          if (ats==null){
              //创建新方案对象
              ats=  new AtsSchemeExpert();
          }
        //返回专家咨询对象
        return ats;
    }


    /**
     * 申请审核
     * @param atsSchemeExpert 专家咨询对象
     * @param request 请求对象
     * @return message 消息对象
     */
    @ResponseBody
    @RequestMapping("addAtsSchemeExpert")
    public Message addAtsSchemeExpert(AtsSchemeExpert atsSchemeExpert,HttpServletRequest request,Integer isId){
        System.out.println("sdsd:"+isId);
        //获取session对象
        HttpSession session = request.getSession();
        //从session获取manager
        UserVo user = (UserVo)session.getAttribute("manager");
        //设置专家咨询排序为1
        atsSchemeExpert.setSort(1);
        //设置专家咨询创建人为当前登录人
        atsSchemeExpert.setCreater(user.getUsName());
        //设置专家咨询创建时间为当前时间
        atsSchemeExpert.setCreatTime(new Date());
        //设置专家咨询是否有效为有效
        atsSchemeExpert.setIsva(1);
        //设置专家咨询的审核状态为申请中
        atsSchemeExpert.setAuditState("10");
        //设置专家咨询申请时间为当前时间
        atsSchemeExpert.setApplyForTime(Tools.getCurDateTime());

        //创建审核对象
        AtsSchemeAudit audit = new AtsSchemeAudit();
        //设置审核外键为专家咨询的方案ID
        audit.setSaId(String.valueOf(atsSchemeExpert.getSchemeId()));
        //设置审核
        audit.setSaName(atsSchemeExpert.getSaName());
        //设置审核状态为申请
        audit.setAuditState("10");
        //设置审核排序为1
        audit.setSort(1);
        //设置审核创建人为当前登录人
        audit.setCreater(user.getUsName());
        //设置审核创建时间为当前时间
        audit.setCreatTime(new Date());
        //设置审核是否有效为有效
        audit.setIsva(1);
        //定义变量
        int rows = 0;
        //如果id为1那就是修改
        if(isId==1){
            //调用修改专家咨询方法
            rows =  atsSchemeExpertService.updateByschemeKey(atsSchemeExpert);
            //调用根据外键修改审核方法
            rows =  atsSchemeAuditService.updateAuditBySaId(audit);
        }else{
            //调用新增专家咨询方法
            rows = atsSchemeExpertService.insertSelective(atsSchemeExpert);
            //调用新增审核方法
            rows = atsSchemeAuditService.insertSelective(audit);
        }
        //创建消息对象
        Message m = new Message();
        //如果成功
        if(rows>0){
            m.setNum(1);
            m.setMsg("申请成功");
        }else{
            m.setNum(0);
            m.setMsg("申请失败");
        }
        //返回消息
        return m;
    }
}
